package com.ophelisis.common.util;

import java.io.File;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.MessageDigest;
import java.text.DecimalFormat;
import java.util.regex.Pattern;

import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang.StringUtils;


/** ****************************************************************************
 * 문자열과 관련된 함수 모음 클래스.
 **************************************************************************** */
public class StringUtil extends StringUtils {

	static final char FS = File.separatorChar;
    static final String FSStr = String.valueOf(File.separatorChar);
	/**
	 * 문자열이 비어 있는지 체크한다.
	 */
	public static boolean isEmpty(String str) {
		return str==null || "".equals(str);
	}

	public static String nvl(String str) {
	    return str==null ? "" : str;
	}

	public static String nvl(Object obj) {
	    return obj==null ? "" : nvl(String.valueOf(obj));
	}

	public static String nvl(String str, String def) {
	    return (str != null && !"".equals(str)) ? str : def;
	}

	public static String nvl(Object obj, String def) {
	    return obj==null ? "" : nvl(String.valueOf(obj), def);
	}
	
	public static double nvl(Object source,double value) {
		return nvl(String.valueOf(source), value);
	}

	public static float nvl(Object source,float value) {
		return nvl(String.valueOf(source), value);
	}

	public static int nvl(Object source,int value) {
		return nvl(String.valueOf(source), value);
	}

	public static double nvl(String src, double def) {
		try {
			return src==null ? def : Double.parseDouble(src);
		} catch (Exception e) {
			return def;
		}
	}

	public static float nvl(String src, float def) {
		try {
			return src==null ? def : Float.parseFloat(src);
		} catch (Exception e) {
			return def;
		}
	}

	public static long nvl(String src, long def) {
		try {
			return src==null ? def : Long.parseLong(src);
		} catch (Exception e) {
			return def;
		}
	}
	
	public static int nvl(String src, int def) {
		try {
			return src==null ? def : Integer.parseInt(src);
		} catch (Exception e) {
			return def;
		}
	}

//	@SuppressWarnings("unchecked")
//	public static <T> T nvl(Object object, T def) {
//		T ret = null;
//		Class typea = def.getClass();
//		if(object==null) return def;
//		try {
//			if(typea == int.class) {
//				ret = (T) Integer.parseInt(String.valueOf(object));
//			}
//		} catch (Exception e) {
//			ret = def;
//		}
//		return ret;
//	}

	// StringEscapeUtils 관련 함수 Start ***************************************//
	public static String escapeHtml(String str) {
		//return StringEscapeUtils.escapeHtml(str);
		str = replace(str, "'", "&#39;");
		str = replace(str, "\"", "&#34;");
		str = replace(str, ",", "&#44;");
		str = replace(str, "<", "&lt;");
		str = replace(str, ">", "&gt;");
		return str;
	}

	public static String escapeHtmlBr(String str) {
		String ret = str.replaceAll("<", "&lt;").replaceAll("\r\n", "<br>")
					.replaceAll("\n", "<br>").replaceAll("\"", "&quot;")
					.replaceAll(" ", "&nbsp;");
		return ret;
	}

	public static String escapeJava(String str) {
		return StringEscapeUtils.escapeJava(str);
	}

	public static String escapeJavaScript(String str) {
		//return StringEscapeUtils.escapeJavaScript(str);
		str = replace(str, "\"", "\\\"");
		str = replace(str, "'", "\\\'");
		str = replace(str, "\r\n", "\\n");
		str = replace(str, "\n", "\\n");
		return str;
	}

	public static String escapeHtmlJavaScript(String str) {
		str = escapeHtml(str);
		str = replace(str, "&#34", "\\&#34");
		str = replace(str, "&#39", "\\&#39");
		return str;
	}

	public static String escapeSql(String str) {
		return StringEscapeUtils.escapeSql(str);
	}

	public static String escapeXml(String str) {
		return StringEscapeUtils.escapeXml(str);
	}

	public static String unescapeHtml(String str) {
		return StringEscapeUtils.unescapeHtml(str);
	}

	public static String unescapeJava(String str) {
		return StringEscapeUtils.unescapeJava(str);
	}

	public static String unescapeJavaScript(String str) {
		return StringEscapeUtils.unescapeJavaScript(str);
	}

	public static String unescapeXml(String str) {
		return StringEscapeUtils.unescapeXml(str);
	}

	// StringEscapeUtils Wrapper 관련 함수 End ***************************************//

	/** 주민번호 표시(1234561234567 -> 123456-1234567) */
	public static String getFmtJuminNo(String jumin_no) {
	    return getFmtJuminNo(jumin_no, false);
	}

	/** 주민번호 뒷자리 ** 표시 (1234561234567 -> 123456-*******) */
	public static String getFmtJuminNo(String jumin_no, boolean crypt) {
	    String retStr = "";
	    jumin_no = jumin_no == null ? jumin_no = "" : jumin_no.trim();

	    if (jumin_no.length()>6) {
	        retStr = jumin_no.substring(0,6) + "-";
	        retStr += crypt ? "*******" : jumin_no.substring(6) ;
	    }
	    return retStr;
	}

	/** 주민번호 뒷자리 ** 표시 (1234561234567 -> 123456-*******) */
	public static String getCryptJuminNo(String jumin_no) {
		return getFmtJuminNo(jumin_no, true);
	}

	/** 주민번호 뒷자리 ** 표시 (1234561234567 -> 123456-1******) */
	public static String getCryptJuminNo2(String jumin_no) {
	    String retStr = "";
	    jumin_no = jumin_no == null ? jumin_no = "" : jumin_no.trim().replaceAll("-","");

	    if (jumin_no.length()>7) {
	        retStr = jumin_no.substring(0,6) + "-";
	        retStr += jumin_no.substring(6,7) + "******";
	    }
	    return retStr;
	}


	/** 주민번호 배열로 자르기
	 * splitJuminNo("1234561234567")[0] -> 123456
	 * splitJuminNo("1234561234567")[1] -> 1234567
	 */
	public static String[] splitJuminNo(String jumin_no) {
	    return splitJuminNo(jumin_no, false);
	}

	/** 주민번호 암호화 해서 배열로 자르기
	 * splitJuminNo("1234561234567")[0] -> 123456
	 * splitJuminNo("1234561234567")[1] -> *******
	 */
	public static String[] splitJuminNo(String jumin_no, boolean crypt) {
	    String[] retArr = new String[]{"",""};

	    jumin_no = jumin_no == null ? "" : jumin_no.trim().replaceAll("-","");
	    if (jumin_no.length()>=6) {
	        retArr[0] = jumin_no.substring(0,6);
	        retArr[1] = crypt ? "*******" : jumin_no.substring(6) ;
	    } else {
	    	retArr[0] = jumin_no;
	    	retArr[1] = crypt ? "*******" : "";
	    }
	    return retArr;
	}

	/** 사업자번호 자르기 */
	public static String[] splitSaupNo(String saup_no) {
	    String[] retArr = new String[]{"","",""};

	    saup_no = saup_no == null ? "" : saup_no.trim().replaceAll("-","");
        retArr[0] = StringUtil.mid(saup_no, 0, 3);
        retArr[1] = StringUtil.mid(saup_no, 3, 2);
        retArr[2] = StringUtil.mid(saup_no, 5, 10);
	    return retArr;
	}

	public static String getFmtSaupNo(String saup_no) {
		String[] retArr = splitSaupNo(saup_no);
	    return StringUtil.isEmpty(retArr[0]) ? "" : retArr[0]+"-"+retArr[1]+"-"+retArr[2];
	}

	/** 전화번호
	 * getFmtTelNo("02","1234","5678") -> "02-1234-5678"
	 */
	public static String getFmtTelNo(String telno1, String telno2, String telno3) {
		return getFmtTelNo(telno1, telno2, telno3, true);
	}

	/** 전화번호
	 * getFmtTelNo("02","1234","5678") -> "02-1234-5678"
	 * getFmtTelNo("","1234","5678", false) -> "" no1, no2, no3가 하나라도 없으면 "" 리턴
	 */
	public static String getFmtTelNo(String telno1, String telno2, String telno3, boolean ignoreEmpty) {
		telno1 = telno1==null ? "" : telno1.trim();
		telno2 = telno2==null ? "" : telno2.trim();
		telno3 = telno3==null ? "" : telno3.trim();

		if(!ignoreEmpty) {
			if(StringUtil.isEmpty(telno1) || StringUtil.isEmpty(telno2)
				|| StringUtil.isEmpty(telno3)) {
				return "";
			}
		}
		return telno1 + "-" + telno2 + "-" + telno3;
	}

	/** 전화번호에 - 추가
	 * getFmtTelNo("02 1234 5678") -> "02-1234-5678"
	 * getFmtTelNo("02-1234-5678") -> "02-1234-5678"
	 * getFmtTelNo("0212345678") -> "02-1234-5678"
	 */
	public static String getFmtTelNo(String telno) {
		String[] arr = splitTelNo(telno);
		if("".equals(arr[0])) return "";
		if("".equals(arr[2])) return arr[0] + "-" + arr[1];
		return arr[0] + "-" + arr[1] + "-" + arr[2];
	}

	/** 전화번호를 12자리로(전문용)
	 * getFmtTelNo("02 1234 5678") -> "02  12345678"
	 * getFmtTelNo("02-1234-5678") -> "02  12345678"
	 * getFmtTelNo("0212345678") -> "02  12345678"
	 */
	public static String getFmtTelNo12(String telno) {
		String[] arr = splitTelNo(telno);
		return StringUtil.rpad(arr[0],4," ") + StringUtil.rpad(arr[1],4," ") + StringUtil.rpad(arr[2],4," ");
	}

	/** 전화번호 자르기
	 * splitTelNo("02 1234 5678")[0]
	 * splitTelNo("02-1234-5678")[1]
	 * splitTelNo("0212345678")[2]
	 */
	public static String[] splitTelNo(String telno) {
		String[] ret = new String[]{"","",""};
		telno = nvl(telno, "").replaceAll("[- ]", "");
		if("".equals(telno)) return ret;
		int len = telno.length();
		if(len<8) return ret;
		if(len==7) {
			ret[0] = substring(telno,0,3);
			ret[1] = substring(telno,3, 7);
		} else if(len==8) {
			ret[0] = substring(telno,0,4);
			ret[1] = substring(telno,4, 8);
		} else if(telno.startsWith("02")) {
			if(len==9) {
				ret[0] = substring(telno,0,2);
				ret[1] = substring(telno,2,5);
				ret[2] = substring(telno,5,9);
			} else {
				ret[0] = substring(telno,0,2);
				ret[1] = substring(telno,2,6);
				ret[2] = substring(telno,6,10);
			}
		} else if(len==10){
			ret[0] = substring(telno,0,3);
			ret[1] = substring(telno,3, 6);
			ret[2] = substring(telno,6,10);
		} else if(len==11){
			ret[0] = substring(telno,0,3);
			ret[1] = substring(telno,3, 7);
			ret[2] = substring(telno,7,11);
		} else {
			ret[0] = substring(telno,0,4);
			ret[1] = substring(telno,4, 8);
			ret[2] = substring(telno,8,12);
		}
		return ret;
	}

	/** email 자르기
	 * splitEmail("no@spam.com")[0] => "no"
	 * splitEmail("no@spam.com")[1] => "spam.com"
	 */
	public static String[] splitEmail(String email) {
		return splitTwoWords(email,"@");
	}

	/**
	 * email 개인정보 표시규치 적용
	 * 입력값 test@email.com  -> 반환값 te**@email.com
	 */
	public static String getFmtEmail(String email){
		String [] retStr = new String[]{"",""};

		retStr = splitEmail(email);
		if(!"".equals(retStr[0]) && !"".equals(retStr[1])) {
			email = getFmtCrypt(retStr[0], 2)+"@"+retStr[1];
		}
		return email;

	}

	/** delim 문자로 자르기(delim문자로 구분된 두 문자열 형태인 경우)
	 * splitAt("no@spam.com")[0] => "no"
	 * splitAt("no@spam.com")[1] => "spam.com"
	 */
	public static String[] splitTwoWords(String str, String delim) {
		String[] retStr = new String[]{"",""};
		str = str== null ? "" : str.trim();

		int idx = str.indexOf(delim);
		if(idx==-1) {
			retStr[0] = str;
		} else {
			retStr[0] = str.substring(0, idx);
			retStr[1] = str.substring(idx+1);
		}
		return retStr;
	}


	/** 증권번호 별표시
	 * 뒷 6자리를 *표로 바꾼다.
	 * K12346-123-456	=> K12346-***-***
	 * K12346123456	=> K12346******
	 */
	public static String getCryptPolyNo(String str) {
		return getFmtCrypt(str, 6);
	}

	/** 계좌번호 별표시
	 * 뒷 6자리를 *표로 바꾼다.
	 * K12346-123-456	=> K12346-***-***
	 * K12346123456	=> K12346******
	 */
	public static String getCryptAccNo(String str) {
		return getFmtCrypt(str, 6);
	}

	/** str 뒤에서 len 자리만큼 * 처리 */
	public static String getFmtCrypt(String str, int len) {
		if(StringUtil.isEmpty(str)) return str;
		char[] data = str.toCharArray();
		int idx = data.length-1;
		while(len>0 && idx>=0) {
			if('-'!=data[idx]) {
				data[idx] = '*';
				len--;
			}
			idx--;
		}
		return new String(data);
	}

	/** 우편번호 자르기 */
	public static String[] splitZipNo(String zip_no) {
		String[] retStr = new String[]{"",""};
		zip_no = zip_no== null ? "" : zip_no.trim().replaceAll("-", "");

	    if (zip_no.length()>=3) {
	        retStr[0] = zip_no.substring(0,3);
	        retStr[1] = zip_no.substring(3);
	    } else {
	    	retStr[0] = zip_no;
	    }
		return retStr;
	}

	/**
	 * 문자열 왼쪽에 원하는 수만큼의 문자를 붙여서 리턴한다.
	 * @param str 기본 문자열
	 * @param i   리턴받는 문자열의 길이
	 * @param padStr 왼쪽에 포함되는 문자
	 * @return reStr 리턴 받을 문자열
	 */
	public static String lpad(String str, int i, String padStr) {
		String rtnStr = "";

		if (str == null || i == 0) {
			return str;
		} else {
			rtnStr = str;
		}

		for (int j = str.length(); j < i; j++) {
			rtnStr = padStr + rtnStr;
		}

		if (rtnStr.length() == i) {
			return rtnStr;
		} else {
			return str;
		}
	}

	/** 문자열 오른쪽에 원하는 수만큼의 공백를 붙여서 리턴한다. */
	public static String rpad(String str, int cnt) {
		return rpad(str, cnt, " ");
	}

	/** 문자열 오른쪽에 원하는 수만큼의 문자를 붙여서 리턴한다. */
	public static String rpad(String str, int cnt, String padStr) {
		if(str==null) str = "";
		while (str.length() < cnt) {
			str =  str + padStr;
		}
		return str;
	}

	/** rpad와 유사, 입력값을 byte로 계산 */
	public static String rpadb(String str, int len) {
		return rpadb(str, len, ' ');
	}

	/** rpad와 유사, 입력값을 byte로 계산 */
	public static String rpadb(String str, int len, char ch) {
		return rpadb(str, len, (byte) ch);
	}

	/** rpad와 유사, 입력값을 byte로 계산 */
	public static String rpadb(String str, int len, byte by) {
		byte[] retBytes = new byte[len];
		byte[] indata = str.getBytes();
		for (int i = 0; i < len; i++) {
			if (indata.length > i)
				retBytes[i] = indata[i];
			else
				retBytes[i] = by;
		}
		return new String(retBytes);
	}

	/** byte[]를 문자열로 표현 */
	public static String toHexString(byte[] bytes) {
		if (bytes == null) return null;

		StringBuffer strb = new StringBuffer(bytes.length);
	    for (int i=0; i<bytes.length; i++) {
	    	strb.append(toHexString(bytes[i]));
		}

		return strb.toString();
	}

	/** byte를 문자열로 표현 */
	public static String toHexString(byte b) {
		int c = b & 0xff;
		return (c<16 ? "0" : "") + Integer.toHexString(c);
	}

	/** 문자열을 전각문자(전자)로 변경, conv2IBM */
	public static String convCharToFull(String str) {
		char[] chars = str.toCharArray();
		for(int i=0; i<chars.length; i++) {
			if(chars[i]<32 || chars[i]>126) continue;
			chars[i] = (chars[i]==32) ? '　' : (char) ((int) chars[i] + 65248);
		}
		return new String(chars);
	}
	/** 문자열 반각문자(반자)로 변경, conv2WebCode */
	public static String convCharToHalf(String str) {
		char[] chars = str.toCharArray();
		for(int i=0; i<chars.length; i++) {
			if(chars[i]<32+65248 || chars[i]>126+65248) continue;
			chars[i] = (chars[i]==32+65248) ? ' ' : (char) ((int) chars[i] - 65248);
		}
		return new String(chars);
	}

	/** md5 데이콤 결제용 */
	public static String getMD5String(String msg) {
		MessageDigest md = null;
		try {
			md = MessageDigest.getInstance("MD5");
			md.update(msg.getBytes());
		} catch (Exception e) {
		}
		//return asString(md.digest());
		byte[] digest = md.digest();
		StringBuffer strb = new StringBuffer();
	    for (int i = 0; i < digest.length; i++) {
			int c = digest[i] & 0xff;
			if (c <= 15) {
				strb.append("0");
			}
			strb.append(Integer.toHexString(c));
		}
	    return strb.toString();
	}

	/** byte수 길이만큼 왼쪽부터 문자열을 잘라옴 */
	public static String getLeftByte(String str, int len) {
		return getLeftByteString(str, len);
	}

	/** byte수 길이만큼 왼쪽부터 문자열을 잘라옴, 잘른 경우 "..." 대체 문자 삽입 */
	public static String cutFmtString(String str, int len) {
		return strCut(str, null, len, 0, true, true);
	}
	public static String cutString(String str, int len) {
		String addon = "...";
		return cutString(str, len, addon);
	}
	public static String cutString(String str, int len, String addon) {
		if ( str == null ) return "";
		if ( len > str.length() ) return str;
		
		if ( addon == null ) addon = "";
		
		int addonlen = addon.length();
		String res = str.substring(0, len-addonlen);
		return rpad(res, len, addon);
	}

	// 외부에서 빌어온 함수
	public static String strCut(String szText, String szKey, int nLength, int nPrev, boolean isNotag, boolean isAdddot){  // 문자열 자르기
	    
	    String r_val = szText;
	    int oF = 0, oL = 0, rF = 0, rL = 0; 
	    int nLengthPrev = 0;
	    Pattern p = Pattern.compile("<(/?)([^<>]*)?>", Pattern.CASE_INSENSITIVE);  // 태그제거 패턴
	   
	    if(isNotag) {r_val = p.matcher(r_val).replaceAll("");}  // 태그 제거
	    r_val = r_val.replaceAll("&amp;", "&");
	    r_val = r_val.replaceAll("(!/|\r|\n|&nbsp;)", "");  // 공백제거
	 
	    try {
	      byte[] bytes = r_val.getBytes("UTF-8");     // 바이트로 보관
	      if(szKey != null && !szKey.equals("")) {
	        nLengthPrev = (r_val.indexOf(szKey) == -1)? 0: r_val.indexOf(szKey);  // 일단 위치찾고
	        nLengthPrev = r_val.substring(0, nLengthPrev).getBytes("MS949").length;  // 위치까지길이를 byte로 다시 구한다
	        nLengthPrev = (nLengthPrev-nPrev >= 0)? nLengthPrev-nPrev:0;    // 좀 앞부분부터 가져오도록한다.
	      }
	    
	      // x부터 y길이만큼 잘라낸다. 한글안깨지게.
	      int j = 0;
	      if(nLengthPrev > 0) while(j < bytes.length) {
	        if((bytes[j] & 0x80) != 0) {
	          oF+=2; rF+=3; if(oF+2 > nLengthPrev) {break;} j+=3;
	        } else {if(oF+1 > nLengthPrev) {break;} ++oF; ++rF; ++j;}
	      }
	      
	      j = rF;
	      while(j < bytes.length) {
	        if((bytes[j] & 0x80) != 0) {
	          if(oL+2 > nLength) {break;} oL+=2; rL+=3; j+=3;
	        } else {if(oL+1 > nLength) {break;} ++oL; ++rL; ++j;}
	      }
	      
	      //System.out.println("===============> bytes::"+toHexString(bytes)+", rF::"+rF+", rL::"+rF);
	      r_val = new String(bytes, rF, rL, "UTF-8");  // charset 옵션
	      if(isAdddot && rF+rL+3 <= bytes.length) {r_val+="...";}  // ...을 붙일지말지 옵션 
	    } catch(UnsupportedEncodingException e){ e.printStackTrace(); }   
        catch(StringIndexOutOfBoundsException e1){ 
        	//e1.printStackTrace();
        	r_val = cutString(szText, nLength);
        }   
	    
	    return r_val;
	  }
	
	/** byte수 길이만큼 왼쪽부터 문자열을 잘라옴 */
	public static String getLeftByteString(String str, int len) {
		String ret = "";
		char[] chars = str.toCharArray();
		int idx = 0;
		for(idx=0; idx<chars.length && len>0; idx++) {
			String s = String.valueOf(chars[idx]);
			len -= s.getBytes().length;
			//if (chars[idx]>=0xAC00 && chars[idx]<=0xD7A3) {
		}
		ret = new String(ArrayUtils.subarray(chars, 0, len<0 ? idx-1 : idx));
		if(len<0) ret += rpad("", Math.abs(len));
		return ret;
	}

	/** byte수 길이만큼 왼쪽부터 문자열을 자르고 공백으로 rpadb */
	public static String getLeftByteRpadb(String str, int len) {
		return rpadb(getLeftByteString(str.trim(),len),len);
	}

	/** byte 수 길이 구함 */
	public static int getByteLength(String str) {
		return str.getBytes().length;
	}

	public static boolean isHPhone(String number){
		if(number == null) return false;

		//if(number.length() >= 3 && equalsArray(number.substring(0,3), new String[]{"010","011","016","017","018","019","013","070","050"})) return true;
//		if(number.length() > 4 && equalsArray(number.substring(0,4), new String[]{"0130","0505"})) return true;

		return false;
	}

//	public static String getFmtAmtPercentage(double val1) {
//		if ( val1 < 100 )  getFmtAmt(val1) - 0.01)
//		else 
//	}
	
    public static String getFmtAmt(double val1) {
    	return getFmtAmt(val1, 0);
    }

    public static String getFmtAmt(double val1, int sosu) {
        String out = "";
        String numFormat = "###,###,###,###,###,##0";
        if(sosu>0) numFormat +=".";
        for (int i = 0; i < sosu; i++)
            numFormat += "0";
        DecimalFormat formatter = new DecimalFormat(numFormat);
        out = formatter.format(val1);
        return out;
    }

	public static String getFmtAmt(String amt, int sosu) {
	    if (amt.trim().equals("")) {
	        amt = "0";
	    }
	    return getFmtAmt(Double.parseDouble(amt), sosu);
	}


	/** 대문자 스트링을 리턴 */
	public static String upperCase(String pString) {
		if (isEmpty(pString)) return "";
		else return pString.toUpperCase();
	}

	/** 소문자 스트링을 리턴 */
	public static String lowerCase(String pString) {
		if (isEmpty(pString)) return "";
		else return pString.toLowerCase();
	}

	public static String getFmtByte(double val) {
		return getFmtByte(val, 1024);
	}
	public static String getFmtByte(double val, int unit) {
		String[] ext = new String[]{"B","KB","MB","GB","TB","PB","EB","ZB","YB"};
		int extpos = 0;
		for(; val>unit; extpos++) val /= unit;
		return StringUtil.getFmtAmt(val, extpos==0 ? 0 : 1) + " " + ext[extpos];
	}
	public static String getFmtByte(String val, int unit) {
	    if (val.trim().equals("")) {
	    	val = "0";
	    }
	    return getFmtByte(Double.parseDouble(val), unit);
	}
	public static String getFmtByte(String val) {
	    if (val.trim().equals("")) {
	    	val = "0";
	    }
	    return getFmtByte(Double.parseDouble(val));
	}

	public static Integer getInteger(String val) {
	    if (val.trim().equals("")) {
	    	val = "0";
	    }
	    return Integer.parseInt(val);
	}

	public static Double getDouble(String val) {
	    if (val.trim().equals("")) {
	    	val = "0";
	    }
	    return Double.parseDouble(val);
	}
	public static Long getLong(String val) {
	    if (val.trim().equals("")) {
	    	val = "0";
	    }
	    return Long.parseLong(val);
	}
	public static Float getFloat(String val) {
	    if (val.trim().equals("")) {
	    	val = "0";
	    }
	    return Float.parseFloat(val);
	}

	public static String getValuePercentage(String tot, String rate) {
	    double val = Double.parseDouble(nvl(tot,"0"))* Double.parseDouble(nvl(rate,"0"))/100;
	    return getFmtByte(val);
	}
	public static String getValuePercentage(double tot, String rate) {
	    double val = tot* Double.parseDouble(nvl(rate,"0"))/100;
	    return getFmtByte(val);
	}
	public static String getValuePercentage(float tot, String rate) {
	    float val = tot* Float.parseFloat(nvl(rate,"0"))/100;
	    return getFmtByte(val);
	}
	
	public static void main(String[] args) {
	}

	//2008-03-27 이정훈추가
	public static String zeroDel(int num){
		return num == 0 ? "" : String.valueOf(num);
	}

    /**
     * <pre>
     * 두문자열을 대문자로 변환후 비교한다.
     * null인 스트인입력시 false 리턴한다.
     * </pre>
     * @param string1
     * @param string2
     * @return String
     */
    public static final boolean capitalEquals(String string1, String string2) {
    	boolean retBoolean = false;
        try {
            if(string1 == null || string2 == null) {
            	retBoolean = false;
            } else if((string1.toUpperCase()).equals(string2.toUpperCase())) {
            	retBoolean = true;
            } else {
            	retBoolean = false;
            }
        } catch(Exception e) {
        }
        return retBoolean;
    }


    /**
     * <pre>
     * null또는 ""인지를 판단한다.
     * </pre>
     * @param src 대상스트링
     * @return boolean true : null 또는  "", false : 값있음.
     */
    public static final boolean isNull(String src) {
    	if(src == null || src.equals("") || capitalEquals(src, "NULL")) {
    		return true;
    	}
    	return false;
    }

    /**
     * <pre>
     * !(null, "", "null")인지를 판단한다.
     * </pre>
     * @param src 대상스트링
     * @return boolean true : 값있음  "", false : null 또는.
     */
    public static final boolean isNotNull(String src) {
    	if(!isNull(src)) {
    		return true;
    	}
    	return false;
    }


    /**
     * <pre>
     * 문자열에서 파일명을 추출한다.
     * null인 스트인입력시 "" 리턴한다.
     * </pre>
     * @param FullPathStr
     * @return String
     */
	public static final String getFileNameFull(String FullPathStr) {
		String rResStr = "";
		String tmpStr = "";
		int PathCount = 0;

		if ( isNotNull(FullPathStr) ) {
			tmpStr = convertPathString(FullPathStr);
			PathCount = getIndexCount(tmpStr, FSStr);
			// /가 존재 하는 경우 최종 /이후의 String을 구한다.
			if ( PathCount > 0 ) tmpStr = getIndexString(tmpStr, FSStr, PathCount );

			rResStr = tmpStr;
		}

		return rResStr;
	}

    /**
     * <pre>
     * 문자열에서 파일명을 추출한다.
     * null인 스트인입력시 "" 리턴한다.
     * </pre>
     * @param FullPathStr
     * @return String
     */
	public static final String getFileName(String FullPathStr) {
		String rResStr = "";
		String tmpStr = "";
		int PathCount = 0;
		int PointCount = 0;

		if ( isNotNull(FullPathStr) ) {
			tmpStr = convertPathString(FullPathStr);
			PathCount = getIndexCount(tmpStr, FSStr);
			// /가 존재 하는 경우 최종 /이후의 String을 구한다.
			if ( PathCount > 0 ) tmpStr = getIndexString(tmpStr, FSStr, PathCount );

			PointCount = tmpStr.lastIndexOf(".");
			if ( PointCount > 0 ) rResStr = tmpStr.substring(0, PointCount);
			else rResStr = tmpStr;
		}

		return rResStr;
	}

    /**
     * <pre>
     * 문자열에서 파일확장자명을 추출한다.
     * null인 스트인입력시 "" 리턴한다.
     * </pre>
     * @param FullPathStr
     * @return String
     */
	public static final String getFileExt(String FullPathStr) {
		String rResStr = "";
		String tmpStr = "";
		int PathCount = 0;
		int PointCount = 0;

		if ( isNotNull(FullPathStr) ) {
			tmpStr = convertPathString(FullPathStr);
			PathCount = getIndexCount(tmpStr, FSStr);
			// /가 존재 하는 경우 최종 /이후의 String을 구한다.
			if ( PathCount > 0 ) tmpStr = getIndexString(tmpStr, FSStr, PathCount );

			PointCount = getIndexCount(tmpStr, ".");
//			PointCount = tmpStr.lastIndexOf(".");
			if ( PointCount > 0 ) rResStr = getIndexString(tmpStr, ".", PointCount);
			if ( isNotNull(rResStr) ) rResStr = rResStr.toLowerCase();
		}

		return rResStr;
	}

    /**
     * <pre>
     * 입력받은 문자열중 OS 에 맞는 ( / or \ ) 문자열로 변경한다.
     * </pre>
     * @param src 변환할 문자열
     * @return String 변환된 문자열, 에러발생시 src 반환.
     */
    public static String convertPathString(String src) {

    	String retString = src;
        try {
        	if ( isNull(retString) ) return "";
//            retString = replaceAll(retString, "&lt;", "<");
        	retString = replaceAll(retString, "\\\\", FSStr);
        	if ( !FSStr.equals("\\") ) retString = replaceAll(retString, "\\", FSStr);
        	retString = replaceAll(retString, "//", FSStr);
        	if ( !FSStr.equals("/") ) retString = replaceAll(retString, "/", FSStr);

        } catch(Exception e) {
            return retString;
        }
        return retString;
    }

    /**
     * <pre>
     * 특정문자(char)의 갯수를 구한다.
     * </pre>
     * @param str 대상스트링
     * @param delimiter 구분자
     * @return int 구분자의 갯수
     */
    public static final int getIndexCount(String str, String delimiter) {
        int indexCount = 0;
        int fromIndex = 0;
        int toIndex = 0;
        try {
            if ( str == null ) {
                return indexCount;
            }
            while((toIndex = str.indexOf(delimiter, fromIndex)) != -1) {
                indexCount++;
                fromIndex = toIndex+delimiter.length();
            }
        } catch(Exception e) {
        }
        return indexCount;
    }

    /**
     * <pre>
     * 입력받은 delimiter 수에 해당하는 스트링을 꺼낸다.
     * index는 zero base 임.
     * </pre>
     * @param str 대상스트링
     * @param delimiter 구분자
     * @param index 구분자 순번
     * @return String 구분자순번에 해당하는 스트링
     */
    public static final String getIndexString(String str, String delimiter, int index) {
        int indexCount = 0;
        int fromIndex = 0;
        int toIndex = 0;

        String retString = null;

        try {
            while((toIndex = str.indexOf(delimiter, fromIndex)) != -1) {
                if(indexCount == index) {
                    retString = str.substring(fromIndex, toIndex);
                    break;
                }
                indexCount++;
                fromIndex = toIndex+delimiter.length();
            }

            // 마지막 구분자 처리
            if(retString == null && indexCount == index) {
                retString = str.substring(fromIndex, str.length());
            }
        } catch(Exception e) {
        }
        return retString;
    }

    /**
     * <pre>
     * 입력 받은 모든 문자를 변경한다.
     * 자바 1.3 대응 replaceAll method
     * - ATC장일홍대리버젼 -
     * </pre>
     * @param prSrc 소스스트링
     * @param FindStr 대상스트링
     * @param ChgStr 변환스트링
     * @return String 변화스트링으로 치환된 스트링을 리턴한다.
     */
    public static String replaceAll(String prSrc, String FindStr, String ChgStr) {
		int FindPos = 0;

		String RetStr = prSrc;
		while ( RetStr.indexOf(FindStr,0) != -1 ) {
		    FindPos = RetStr.indexOf(FindStr,0);
		    RetStr = RetStr.substring(0,FindPos) + ChgStr + RetStr.substring(FindPos + FindStr.length(),RetStr.length());
		}
		return RetStr;
    }

    /**
     * <pre>
     * 주어진 스트링의 범주 내에서 입력 받은 모든 문자를 변경한다.
     * 자바 1.3 대응 replaceAll method
     * - ATC장일홍대리버젼 -
     * </pre>
     * @param prSrc 소스스트링
     * @param fr 시작 위치
     * @param to 종료 위치
     * @param FindStr 대상스트링
     * @param ChgStr 변환스트링
     * @return String 변화스트링으로 치환된 스트링을 리턴한다.
     */
    public static String replaceAll(String prSrc, int fr, int to, String FindStr, String ChgStr) {
		int FindPos = 0;

		int Strlen = prSrc.length();
		String FrStr = prSrc.substring(0, fr);
		String ToStr = prSrc.substring(to, Strlen);
		String RetStr = prSrc.substring(fr, to);

		while ( RetStr.indexOf(FindStr,0) != -1 ) {
		    FindPos = RetStr.indexOf(FindStr,0);
		    RetStr = RetStr.substring(0,FindPos) + ChgStr + RetStr.substring(FindPos + FindStr.length(),RetStr.length());
		}

		RetStr = FrStr + RetStr + ToStr;
		return RetStr;
    }

    /**
     * <pre>
     * 주어진 스트링에서 배열의 구조를 제외한 데이타에 대해 입력 받은 모든 문자를 변경한다.
     * 자바 1.3 대응 replaceArray method
     * - ATC장일홍대리버젼 -
     * </pre>
     * @param prSrc 소스스트링
     * @param FindStr 대상스트링
     * @param ChgStr 변환스트링
     * @return String 변화스트링으로 치환된 스트링을 리턴한다.
     */
    public static String replaceArray(String prSrc, String FindStr, String ChgStr) {
		int FindPos = 0;

		int Strlen = prSrc.length();

		if ( Strlen < 3 ) return prSrc;

		int fr = 1;
		int to = Strlen - 1;
		String FrStr = prSrc.substring(0, fr);
		String ToStr = prSrc.substring(to, Strlen);
		String RetStr = prSrc.substring(fr, to);

		RetStr = replaceAll(RetStr, "','", "^$@EX");

		while ( RetStr.indexOf(FindStr,0) != -1 ) {
		    FindPos = RetStr.indexOf(FindStr,0);
		    RetStr = RetStr.substring(0,FindPos) + ChgStr + RetStr.substring(FindPos + FindStr.length(),RetStr.length());
		}

		RetStr = FrStr + RetStr + ToStr;
		RetStr = replaceAll(RetStr, "^$@EX", "','");

		return RetStr;
    }


	/**
	 * <pre>
	 * Method : chg_space / StringUtil
	 * </pre>
	 * @author APEXCNS,Inc.
	 * @since 2006. 08. 24
	 *
	 * @param resLine
	 * @return
	 */

	public static String chg_space(String resLine) {
		String resStr = "";
		@SuppressWarnings("unused")
		String tmpStr = "";
		String tmpStr1 = "";
		int idx = 0;
		boolean ttt = false;

		while ( true ) {
			idx++;
			resLine = resLine.replaceAll("  ", " ");
			//logger.debug(">["+resLine+"]");

			tmpStr1 = getIndexString( resLine, "  ", 1 );
			if ( tmpStr1 == null || tmpStr1.length() <= 0 ) ttt = true;
			//logger.debug("resBool:"+ttt);
			if ( ttt || idx > 50 ) break;

		}
		resStr = resLine;

		return resStr;
	}


    /**
     * <pre>
     * 체크박스에 사용 YN컬럼에 아무값이 없다면 N으로 셋팅 반환
     * @param YN 체크박스 컬럼의 값
     * @return String
     * </pre>
     */
    public static String YNCheck(String YN)
    {
    	if(YN.equals(""))
    	{
    		YN = "N";
    	}
    	return YN;
    }

	/**
	 * @see 왼쪽의 공백을 제거한다.
	 */
	public static final String lTrim(String s) {
		try {
			int pos = 0;
			char[] val = s.toCharArray();
			int len = val.length;

			while ((pos < len) && ((val[pos] <= ' ') || (val[pos] == '\t') ) )		pos++;

			return ( pos > 0 ) ? s.substring(pos, len) : s;
		} catch ( Exception e ) {
			return "";
		}
	}


	/**
	 * @see 오른쪽의 공백을 제거한다.
	 */
	public static final String rTrim(String s) {
		try {
			char[] val = s.toCharArray();
			int pos = val.length;

			while ((pos > 0) && ((val[pos - 1] <= ' ') || (val[pos-1] == '\t')))	pos--;

			return ( pos < val.length ) ? s.substring(0, pos) : s;
		} catch ( Exception e ) {
			return "";
		}
	}

	/**
	 * @see 오른쪽에 특정문자로 빈 자리수만큼 체운다.
	 */
	public static final String rPadding(String str,int len, String sep) {
		String retStr = str;
		int forCnt = 0;

		for ( forCnt = 1; forCnt <= len - str.length(); forCnt++ ) {
			retStr = retStr + sep;
		}

		return retStr;
	}

	// New by Jeong 2003.08.27
	/**
	 * @see 왼쪽에 특정문자로 빈 자리수만큼 체운다.
	 */
	public static final String lPadding(String str,int len, String sep) {
		String retStr = str;
		int forCnt = 0;

		for ( forCnt = 1; forCnt <= len - str.length(); forCnt++ ) {
			retStr = sep + retStr;
		}

		return retStr;
	}

	public static String encodeUrl(String url) {
		String ret = "";
		try {
			ret = URLEncoder.encode(url, "UTF-8");
		} catch (UnsupportedEncodingException e) {
		}
		return ret;
	}

	/** String배열을 원하는 prefix로 desplit함.
	 * @param strArr
	 * @param prefix
	 * @return String
	 */
	public static String desplitStr(String[] strArr, char prefix) {
		String rtnStr = "";
		if(strArr != null)
			for(int i=0; i < strArr.length; i++)
				rtnStr += ("'"+strArr[i]+"'"+(strArr.length-1!=i?prefix:""));
		return rtnStr;
	}

	public static String desplitStr(String[][] strArr, char prefix) {
		String rtnStr = "";
		if(strArr != null)
			for(int i=0; i < strArr.length; i++) {
				//rtnStr += ("'"+strArr[i][pos]+"'"+(strArr.length-1!=i?prefix:""));
			    	rtnStr += ("'{");
				for(int j=0; j < strArr[i].length; j++) {
				    rtnStr += ("'"+strArr[i][j]+"'"+(strArr[i].length-1!=j?prefix:""));
				}
				rtnStr += ("}'"+(strArr.length-1!=i?prefix:""));
			}
		return rtnStr;
	}

	public static String desplitStr(String[][] strArr, int pos, char prefix) {
		String rtnStr = "";
		if(strArr != null)
			for(int i=0; i < strArr.length; i++)
				rtnStr += ("'"+strArr[i][pos]+"'"+(strArr.length-1!=i?prefix:""));
		return rtnStr;
	}
}
